/**
 * 智慧社区管理系统 - 移动端统一权限控制工具函数
 * 
 * 严格按照《智慧社区微服务架构总览.md》的权限体系标准实现
 * 集成权限缓存、监控和性能优化功能
 * 
 * @author Wu.Liang
 * @date 2025-01-30
 * @updated 2025-01-30 - 移动端权限工具创建
 */

import { useUserStore, useAuthStore } from '@/store'
import { computed } from 'vue'
import { propertyInfoApi } from '@/api/propertyInfo'

// 角色代码常量
export const ROLE_CODES = {
  SUPER_ADMIN: 'SUPER_ADMIN',
  ADMIN: 'admin',
  REGION_ADMIN: 'REGION_ADMIN',
  COMMUNITY_ADMIN: 'COMMUNITY_ADMIN',
  PROPERTY_ADMIN: 'PROPERTY_ADMIN',
  PROPERTY_STAFF: 'PROPERTY_STAFF',
  SECURITY_GUARD: 'SECURITY_GUARD',
  USER: 'USER'
}

// 权限类型枚举
export const PermissionType = {
  MENU: 'menu',
  BUTTON: 'button',
  DATA: 'data'
}

// 权限结果对象
export class PermissionResult {
  constructor(hasPermission = false, message = '', code = '') {
    this.hasPermission = hasPermission
    this.message = message
    this.code = code
  }
}

// 权限上下文对象
export class PermissionContext {
  constructor(module = '', action = '', resource = '', userId = '', username = '', userType = '') {
    this.module = module
    this.action = action
    this.resource = resource
    this.userId = userId
    this.username = username
    this.userType = userType
  }
}

// 数据权限范围结果
export class DataScopeResult {
  constructor(hasDataScope = false, scope = []) {
    this.hasDataScope = hasDataScope
    this.scope = scope
  }
}

/**
 * 统一的权限判断工具类
 */
export class PermissionUtils {
  /**
   * 检查是否为超级管理员（带缓存和监控）
   */
  static isSuperAdmin(context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 从authStore获取身份信息
    let isSuperAdmin = authStore.userInfo?.isSuperAdmin || false
    
    // 如果authStore没有，从userStore获取
    if (!isSuperAdmin) {
      isSuperAdmin = userStore.userInfo?.isSuperAdmin || false
    }
    
    // 如果还是没有，从本地存储获取
    if (!isSuperAdmin) {
      isSuperAdmin = uni.getStorageSync('isSuperAdmin') || false
    }
    
    const result = !!isSuperAdmin
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 超级管理员权限检查 - 模块: ${context.module}, 操作: ${context.action}, 结果: ${result}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 检查是否为业主用户
   */
  static isOwnerUser(context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 从authStore获取身份信息
    let isOwnerUser = authStore.userInfo?.isOwnerUser || false
    
    // 如果authStore没有，从userStore获取
    if (!isOwnerUser) {
      isOwnerUser = userStore.userInfo?.isOwnerUser || false
    }
    
    // 如果还是没有，从本地存储获取
    if (!isOwnerUser) {
      isOwnerUser = uni.getStorageSync('isOwnerUser') || false
    }
    
    const result = !!isOwnerUser
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 业主用户权限检查 - 模块: ${context.module}, 操作: ${context.action}, 结果: ${result}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 检查是否为物业公司用户
   */
  static isPropertyCompanyUser(context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 从authStore获取身份信息
    let isPropertyCompanyUser = authStore.userInfo?.isPropertyCompanyUser || false
    
    // 如果authStore没有，从userStore获取
    if (!isPropertyCompanyUser) {
      isPropertyCompanyUser = userStore.userInfo?.isPropertyCompanyUser || false
    }
    
    // 如果还是没有，从本地存储获取
    if (!isPropertyCompanyUser) {
      isPropertyCompanyUser = uni.getStorageSync('isPropertyCompanyUser') || false
    }
    
    const result = !!isPropertyCompanyUser
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 物业公司用户权限检查 - 模块: ${context.module}, 操作: ${context.action}, 结果: ${result}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 检查是否为普通用户
   */
  static isNormalUser(context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 从authStore获取身份信息
    let isNormalUser = authStore.userInfo?.isNormalUser || false
    
    // 如果authStore没有，从userStore获取
    if (!isNormalUser) {
      isNormalUser = userStore.userInfo?.isNormalUser || false
    }
    
    // 如果还是没有，从本地存储获取
    if (!isNormalUser) {
      isNormalUser = uni.getStorageSync('isNormalUser') || false
    }
    
    const result = !!isNormalUser
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 普通用户权限检查 - 模块: ${context.module}, 操作: ${context.action}, 结果: ${result}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 检查是否有关联物业公司（带缓存和监控）
   */
  static async hasPropertyCompany(context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 超级管理员默认有关联物业公司权限
    if (PermissionUtils.isSuperAdmin(context)) {
      return true
    }
    
    // 物业公司用户默认有关联物业公司权限
    if (PermissionUtils.isPropertyCompanyUser(context)) {
      return true
    }
    
    // 从userStore获取物业公司信息
    let hasCompany = userStore.userInfo?.propertyCompanyId || false
    
    // 如果userStore没有物业公司信息，从authStore获取
    if (!hasCompany) {
      hasCompany = authStore.userInfo?.propertyCompanyId || false
    }
    
    // 如果还是没有，尝试从API获取
    if (!hasCompany) {
      try {
        // 调用物业公司相关的API接口
        const response = await propertyInfoApi.hasPropertyCompany()
        hasCompany = response.data || false
        console.log('[权限检查] 从API获取物业公司信息:', hasCompany)
      } catch (error) {
        console.warn('[权限检查] 获取物业公司信息失败:', error)
        hasCompany = false
      }
    }
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 物业公司权限检查 - 模块: ${context.module}, 操作: ${context.action}, 结果: ${hasCompany}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return hasCompany
  }
  
  /**
   * 检查是否有指定权限（带缓存和监控）
   */
  static hasPermission(permission, context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 超级管理员拥有所有权限
    if (PermissionUtils.isSuperAdmin(context)) {
      return true
    }
    
    // 从authStore获取权限列表
    let permissions = authStore.permissions || []
    
    // 如果authStore没有，从userStore获取
    if (permissions.length === 0) {
      permissions = userStore.userPermissions || []
    }
    
    // 如果还是没有，从本地存储获取
    if (permissions.length === 0) {
      try {
        const storedPermissions = uni.getStorageSync('userPermissions')
        if (storedPermissions) {
          permissions = JSON.parse(storedPermissions)
        }
      } catch (error) {
        console.warn('[权限检查] 解析本地存储权限失败:', error)
        permissions = []
      }
    }
    
    const result = permissions.includes(permission)
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 权限检查 - 权限: ${permission}, 模块: ${context.module}, 操作: ${context.action}, 结果: ${result}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 检查是否有数据权限（带缓存和监控）
   */
  static hasDataScope(dataScope, context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 超级管理员拥有所有数据权限
    if (PermissionUtils.isSuperAdmin(context)) {
      return true
    }
    
    // 从userStore获取数据权限信息
    let userDataScope = userStore.userInfo?.dataScope || []
    
    // 如果userStore没有数据权限信息，从authStore获取
    if (!userDataScope || userDataScope.length === 0) {
      userDataScope = authStore.userInfo?.dataScope || []
    }
    
    const result = userDataScope.includes(dataScope)
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 数据权限检查 - 模块: ${context.module}, 操作: ${context.action}, 数据权限: ${dataScope}, 结果: ${result}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 获取用户数据权限范围（带缓存）
   */
  static getDataScope(context = null) {
    const startTime = Date.now()
    
    if (PermissionUtils.isSuperAdmin(context)) {
      return new DataScopeResult(true, ['ALL'])
    }
    
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 从userStore获取数据权限信息
    let userDataScope = userStore.userInfo?.dataScope || []
    
    // 如果userStore没有数据权限信息，从authStore获取
    if (!userDataScope || userDataScope.length === 0) {
      userDataScope = authStore.userInfo?.dataScope || []
    }
    
    const result = new DataScopeResult(userDataScope.length > 0, userDataScope)
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 数据权限范围获取 - 模块: ${context.module}, 操作: ${context.action}, 结果: ${result.hasDataScope}, 范围: ${result.scope}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 检查操作权限（统一入口）
   */
  static async checkOperationPermission(operation, resource = '', context = null) {
    const startTime = Date.now()
    
    try {
      // 构建权限上下文
      const permissionContext = new PermissionContext(
        context?.module || 'unknown',
        context?.action || operation,
        resource,
        context?.userId,
        context?.username,
        context?.userType
      )
      
      // 超级管理员拥有所有权限
      if (PermissionUtils.isSuperAdmin(permissionContext)) {
        return new PermissionResult(true, '超级管理员权限', 'SUPER_ADMIN')
      }
      
      // 检查物业公司权限
      const hasPropertyCompany = await PermissionUtils.hasPropertyCompany(permissionContext)
      if (hasPropertyCompany) {
        return new PermissionResult(true, '物业公司权限', 'PROPERTY_COMPANY')
      }
      
      // 检查具体权限
      const hasPermission = PermissionUtils.hasPermission(operation, permissionContext)
      
      return new PermissionResult(
        hasPermission,
        hasPermission ? '权限检查通过' : '权限不足',
        hasPermission ? 'SUCCESS' : 'PERMISSION_DENIED'
      )
    } catch (error) {
      console.error('[权限检查] 操作权限检查失败:', error)
      return new PermissionResult(false, '权限检查异常', 'ERROR')
    }
  }
  
  /**
   * 检查菜单权限
   */
  static hasMenuPermission(menuCode, context = null) {
    const startTime = Date.now()
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 超级管理员拥有所有菜单权限
    if (PermissionUtils.isSuperAdmin(context)) {
      return true
    }
    
    // 从userStore获取权限信息
    let userPermissions = userStore.userPermissions || []
    
    // 如果userStore没有权限信息，从authStore获取
    if (!userPermissions || userPermissions.length === 0) {
      userPermissions = authStore.permissions || []
    }
    
    const result = userPermissions.includes(menuCode)
    
    // 记录权限检查日志
    if (context) {
      console.log(`[权限检查] 菜单权限检查 - 模块: ${context.module}, 操作: ${context.action}, 菜单: ${menuCode}, 结果: ${result}, 耗时: ${Date.now() - startTime}ms`)
    }
    
    return result
  }
  
  /**
   * 获取用户权限信息
   */
  static getUserPermissionInfo() {
    const userStore = useUserStore()
    const authStore = useAuthStore()
    
    // 合并用户信息
    const userInfo = userStore.userInfo || authStore.userInfo || {}
    const permissions = userStore.userPermissions || authStore.permissions || []
    const roles = userStore.userRoles || userInfo.roles || []
    
    return {
      userId: userInfo.id,
      username: userInfo.username,
      userType: userInfo.userType,
      roles: roles,
      permissions: permissions,
      dataScope: userInfo.dataScope || [],
      propertyCompanyId: userInfo.propertyCompanyId,
      // 身份信息
      isSuperAdmin: PermissionUtils.isSuperAdmin(),
      isOwnerUser: PermissionUtils.isOwnerUser(),
      isPropertyCompanyUser: PermissionUtils.isPropertyCompanyUser(),
      isNormalUser: PermissionUtils.isNormalUser(),
      hasPropertyCompany: !!userInfo.propertyCompanyId
    }
  }
}

/**
 * 权限计算属性管理器
 * 使用computed属性缓存权限判断结果，避免重复计算
 */
export class PermissionComputedManager {
  static computedCache = new Map()
  
  /**
   * 获取超级管理员状态（计算属性）
   */
  static get isSuperAdmin() {
    const key = 'isSuperAdmin'
    if (!this.computedCache.has(key)) {
      this.computedCache.set(key, computed(() => {
        return PermissionUtils.isSuperAdmin(new PermissionContext('computed', 'isSuperAdmin'))
      }))
    }
    return this.computedCache.get(key)
  }
  
  /**
   * 获取物业公司权限状态（计算属性）
   */
  static get hasPropertyCompany() {
    const key = 'hasPropertyCompany'
    if (!this.computedCache.has(key)) {
      this.computedCache.set(key, computed(async () => {
        return await PermissionUtils.hasPropertyCompany(new PermissionContext('computed', 'hasPropertyCompany'))
      }))
    }
    return this.computedCache.get(key)
  }
  
  /**
   * 获取操作权限状态（计算属性）
   */
  static getOperationPermission(operation, resource = '') {
    const key = `operation_${operation}_${resource || 'default'}`
    if (!this.computedCache.has(key)) {
      this.computedCache.set(key, computed(async () => {
        return await PermissionUtils.checkOperationPermission(operation, resource, new PermissionContext('computed', operation, resource))
      }))
    }
    return this.computedCache.get(key)
  }
  
  /**
   * 清除计算属性缓存
   */
  static clearComputedCache() {
    this.computedCache.clear()
    console.log('[权限计算属性] 缓存已清除')
  }
}

// 导出权限检查函数（保持向后兼容）
export function checkRole(role) {
  const userStore = useUserStore()
  const authStore = useAuthStore()
  
  // 超级管理员拥有所有角色
  if (PermissionUtils.isSuperAdmin()) {
    return new PermissionResult(true)
  }
  
  // 检查用户是否登录
  if (!userStore.userInfo && !authStore.userInfo) {
    return new PermissionResult(false, '用户未登录', 'NOT_LOGGED_IN')
  }
  
  // 获取用户角色
  let userRoles = userStore.userRoles || []
  if (!userRoles || userRoles.length === 0) {
    userRoles = authStore.userInfo?.roles || []
  }
  
  // 检查角色
  const hasRole = userRoles.includes(role)
  
  return new PermissionResult(
    hasRole,
    hasRole ? '角色检查通过' : '角色权限不足',
    hasRole ? 'SUCCESS' : 'ROLE_DENIED'
  )
}

export function checkPermission(permission) {
  const userStore = useUserStore()
  const authStore = useAuthStore()
  
  // 超级管理员拥有所有权限
  if (PermissionUtils.isSuperAdmin()) {
    return new PermissionResult(true)
  }
  
  // 检查用户是否登录
  if (!userStore.userInfo && !authStore.userInfo) {
    return new PermissionResult(false, '用户未登录', 'NOT_LOGGED_IN')
  }
  
  // 获取用户权限
  let userPermissions = userStore.userPermissions || []
  if (!userPermissions || userPermissions.length === 0) {
    userPermissions = authStore.permissions || []
  }
  
  // 检查权限
  const hasPermission = userPermissions.includes(permission)
  
  return new PermissionResult(
    hasPermission,
    hasPermission ? '权限检查通过' : '权限不足',
    hasPermission ? 'SUCCESS' : 'PERMISSION_DENIED'
  )
}

export function hasMenuPermission(menuCode) {
  const userStore = useUserStore()
  const authStore = useAuthStore()
  
  // 超级管理员拥有所有菜单权限
  if (PermissionUtils.isSuperAdmin()) {
    return new PermissionResult(true)
  }
  
  // 检查用户是否登录
  if (!userStore.userInfo && !authStore.userInfo) {
    return new PermissionResult(false, '用户未登录', 'NOT_LOGGED_IN')
  }
  
  // 获取用户权限
  let userPermissions = userStore.userPermissions || []
  if (!userPermissions || userPermissions.length === 0) {
    userPermissions = authStore.permissions || []
  }
  
  // 检查菜单权限
  const hasPermission = userPermissions.includes(menuCode)
  
  return new PermissionResult(
    hasPermission,
    hasPermission ? '菜单权限检查通过' : '菜单权限不足',
    hasPermission ? 'SUCCESS' : 'MENU_DENIED'
  )
}

/**
 * 检查物业信息权限
 */
export function checkPropertyInfoPermission(action) {
  const userStore = useUserStore()
  const authStore = useAuthStore()
  
  // 超级管理员拥有所有权限
  if (PermissionUtils.isSuperAdmin()) {
    return new PermissionResult(true)
  }
  
  // 检查用户是否登录
  if (!userStore.userInfo && !authStore.userInfo) {
    return new PermissionResult(false, '用户未登录', 'NOT_LOGGED_IN')
  }
  
  // 检查物业公司权限
  const userInfo = userStore.userInfo || authStore.userInfo || {}
  const hasPropertyCompany = !!userInfo.propertyCompanyId
  
  if (!hasPropertyCompany) {
    return new PermissionResult(false, '未关联物业公司', 'NO_PROPERTY_COMPANY')
  }
  
  // 根据操作类型检查具体权限
  const permissionMap = {
    view: 'property:info:view',
    update: 'property:info:update',
    delete: 'property:info:delete'
  }
  
  const requiredPermission = permissionMap[action]
  const hasPermission = PermissionUtils.hasPermission(requiredPermission)
  
  return new PermissionResult(
    hasPermission,
    hasPermission ? '物业信息权限检查通过' : '物业信息权限不足',
    hasPermission ? 'SUCCESS' : 'PROPERTY_INFO_DENIED'
  )
}

/**
 * 检查是否为管理员角色
 */
export function isAdminRole(roleCode) {
  return [
    ROLE_CODES.SUPER_ADMIN,
    ROLE_CODES.ADMIN,
    ROLE_CODES.PROPERTY_ADMIN,
    ROLE_CODES.COMMUNITY_ADMIN
  ].includes(roleCode)
}

/**
 * 检查是否为超级管理员或物业公司
 */
export function isSuperAdminOrPropertyCompany() {
  return PermissionUtils.isSuperAdmin() || PermissionUtils.hasPropertyCompany()
}

/**
 * 数据权限范围工具函数
 * 用于将数据权限范围转换为用户友好的文本、描述和标签类型
 */

/**
 * 获取数据权限范围文本
 * @param {Array} dataScope 数据权限范围数组
 * @returns {string} 用户友好的权限范围文本
 */
export function getDataScopeText(dataScope = []) {
  if (!dataScope || dataScope.length === 0) {
    return '无数据权限'
  }
  
  // 超级管理员拥有所有权限
  if (PermissionUtils.isSuperAdmin()) {
    return '全部数据'
  }
  
  // 物业公司人员
  if (dataScope.includes('PROPERTY_COMPANY')) {
    return '物业公司数据'
  }
  
  // 社区级别权限
  if (dataScope.includes('COMMUNITY')) {
    return '社区数据'
  }
  
  // 楼栋级别权限
  if (dataScope.includes('BUILDING')) {
    return '楼栋数据'
  }
  
  // 单元级别权限
  if (dataScope.includes('UNIT')) {
    return '单元数据'
  }
  
  // 房户级别权限
  if (dataScope.includes('HOUSEHOLD')) {
    return '房户数据'
  }
  
  // 自定义范围
  if (dataScope.length > 0) {
    return `自定义范围 (${dataScope.length}项)`
  }
  
  return '无数据权限'
}

/**
 * 获取数据权限范围描述
 * @param {Array} dataScope 数据权限范围数组
 * @returns {string} 详细的权限范围描述
 */
export function getDataScopeDescription(dataScope = []) {
  if (!dataScope || dataScope.length === 0) {
    return '您当前没有任何数据访问权限'
  }
  
  // 超级管理员
  if (PermissionUtils.isSuperAdmin()) {
    return '您拥有系统的全部数据访问权限，可以查看和管理所有数据'
  }
  
  // 物业公司人员
  if (dataScope.includes('PROPERTY_COMPANY')) {
    return '您拥有物业公司级别的数据访问权限，可以查看和管理关联物业公司的所有数据'
  }
  
  // 社区级别权限
  if (dataScope.includes('COMMUNITY')) {
    return '您拥有社区级别的数据访问权限，可以查看和管理指定社区的数据'
  }
  
  // 楼栋级别权限
  if (dataScope.includes('BUILDING')) {
    return '您拥有楼栋级别的数据访问权限，可以查看和管理指定楼栋的数据'
  }
  
  // 单元级别权限
  if (dataScope.includes('UNIT')) {
    return '您拥有单元级别的数据访问权限，可以查看和管理指定单元的数据'
  }
  
  // 房户级别权限
  if (dataScope.includes('HOUSEHOLD')) {
    return '您拥有房户级别的数据访问权限，可以查看和管理指定房户的数据'
  }
  
  // 自定义范围
  if (dataScope.length > 0) {
    return `您拥有自定义数据访问权限，可以查看和管理 ${dataScope.length} 个指定范围的数据`
  }
  
  return '您当前没有任何数据访问权限'
}

/**
 * 获取数据权限范围标签类型
 * @param {Array} dataScope 数据权限范围数组
 * @returns {string} 标签类型
 */
export function getDataScopeTagType(dataScope = []) {
  if (!dataScope || dataScope.length === 0) {
    return 'danger'
  }
  
  // 超级管理员
  if (PermissionUtils.isSuperAdmin()) {
    return 'success'
  }
  
  // 物业公司人员
  if (dataScope.includes('PROPERTY_COMPANY')) {
    return 'success'
  }
  
  // 社区级别权限
  if (dataScope.includes('COMMUNITY')) {
    return 'warning'
  }
  
  // 楼栋级别权限
  if (dataScope.includes('BUILDING')) {
    return 'warning'
  }
  
  // 单元级别权限
  if (dataScope.includes('UNIT')) {
    return 'info'
  }
  
  // 房户级别权限
  if (dataScope.includes('HOUSEHOLD')) {
    return 'info'
  }
  
  // 自定义范围
  if (dataScope.length > 0) {
    return 'info'
  }
  
  return 'danger'
}

/**
 * 获取数据权限范围图标
 * @param {Array} dataScope 数据权限范围数组
 * @returns {string} 图标名称
 */
export function getDataScopeIcon(dataScope = []) {
  if (!dataScope || dataScope.length === 0) {
    return 'Lock'
  }
  
  // 超级管理员
  if (PermissionUtils.isSuperAdmin()) {
    return 'Star'
  }
  
  // 物业公司人员
  if (dataScope.includes('PROPERTY_COMPANY')) {
    return 'OfficeBuilding'
  }
  
  // 社区级别权限
  if (dataScope.includes('COMMUNITY')) {
    return 'House'
  }
  
  // 楼栋级别权限
  if (dataScope.includes('BUILDING')) {
    return 'OfficeBuilding'
  }
  
  // 单元级别权限
  if (dataScope.includes('UNIT')) {
    return 'Grid'
  }
  
  // 房户级别权限
  if (dataScope.includes('HOUSEHOLD')) {
    return 'User'
  }
  
  // 自定义范围
  if (dataScope.length > 0) {
    return 'Setting'
  }
  
  return 'Lock'
}

/**
 * 检查是否有指定数据权限范围
 * @param {string} requiredScope 需要的权限范围
 * @param {Array} userDataScope 用户的数据权限范围
 * @returns {boolean} 是否有权限
 */
export function hasDataScopePermission(requiredScope, userDataScope = []) {
  if (!userDataScope || userDataScope.length === 0) {
    return false
  }
  
  // 超级管理员拥有所有权限
  if (PermissionUtils.isSuperAdmin()) {
    return true
  }
  
  // 检查是否包含所需权限
  return userDataScope.includes(requiredScope)
}

/**
 * 获取数据权限范围层级
 * @param {Array} dataScope 数据权限范围数组
 * @returns {number} 权限层级 (0-无权限, 1-房户级, 2-单元级, 3-楼栋级, 4-社区级, 5-物业公司级, 6-超级管理员)
 */
export function getDataScopeLevel(dataScope = []) {
  if (!dataScope || dataScope.length === 0) {
    return 0
  }
  
  // 超级管理员
  if (PermissionUtils.isSuperAdmin()) {
    return 6
  }
  
  // 物业公司人员
  if (dataScope.includes('PROPERTY_COMPANY')) {
    return 5
  }
  
  // 社区级别权限
  if (dataScope.includes('COMMUNITY')) {
    return 4
  }
  
  // 楼栋级别权限
  if (dataScope.includes('BUILDING')) {
    return 3
  }
  
  // 单元级别权限
  if (dataScope.includes('UNIT')) {
    return 2
  }
  
  // 房户级别权限
  if (dataScope.includes('HOUSEHOLD')) {
    return 1
  }
  
  return 0
}

// 默认导出
export default {
  PermissionUtils,
  PermissionComputedManager,
  checkRole,
  checkPermission,
  hasMenuPermission,
  checkPropertyInfoPermission,
  isAdminRole,
  isSuperAdminOrPropertyCompany,
  getDataScopeText,
  getDataScopeDescription,
  getDataScopeTagType,
  getDataScopeIcon,
  hasDataScopePermission,
  getDataScopeLevel,
  ROLE_CODES,
  PermissionType
} 